<!DOCTYPE html>



  


<html class="theme-next gemini use-motion" lang="zh-CN">
<head>
  <meta charset="UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"/>
<meta name="theme-color" content="#222">









<meta http-equiv="Cache-Control" content="no-transform" />
<meta http-equiv="Cache-Control" content="no-siteapp" />
















  
  
  <link href="/java-notes/lib/fancybox/source/jquery.fancybox.css?v=2.1.5" rel="stylesheet" type="text/css" />







<link href="/java-notes/lib/font-awesome/css/font-awesome.min.css?v=4.6.2" rel="stylesheet" type="text/css" />

<link href="/java-notes/css/main.css?v=5.1.4" rel="stylesheet" type="text/css" />


  <link rel="apple-touch-icon" sizes="180x180" href="/java-notes/images/apple-touch-icon-next.png?v=5.1.4">


  <link rel="icon" type="image/png" sizes="32x32" href="/java-notes/images/favicon-32x32-next.png?v=5.1.4">


  <link rel="icon" type="image/png" sizes="16x16" href="/java-notes/images/favicon-16x16-next.png?v=5.1.4">


  <link rel="mask-icon" href="/java-notes/images/logo.svg?v=5.1.4" color="#222">





  <meta name="keywords" content="sql,事务," />










<meta name="description" content="MySql数据库设计范式 第一范式（1NF）：要求数据库表的每一列都是不可分割的原子数据项。 某列是地址，其实为了满足第一范式的话还是可以继续分割成省市区列。  第二范式（2NF ）： 在1NF的基础上，非码属性必须完全依赖于候选码（在1NF基础上消除非主属性对主码的部分函数依赖）  如关系模型（职工号，姓名，职称，项目号，项目名称）中，职工号-&gt;姓名，职工号-&gt;职称，而项目号-&amp;gt">
<meta property="og:type" content="article">
<meta property="og:title" content="MySQL知识点">
<meta property="og:url" content="https://hitomeng.gitee.io/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/index.html">
<meta property="og:site_name" content="JavaNote">
<meta property="og:description" content="MySql数据库设计范式 第一范式（1NF）：要求数据库表的每一列都是不可分割的原子数据项。 某列是地址，其实为了满足第一范式的话还是可以继续分割成省市区列。  第二范式（2NF ）： 在1NF的基础上，非码属性必须完全依赖于候选码（在1NF基础上消除非主属性对主码的部分函数依赖）  如关系模型（职工号，姓名，职称，项目号，项目名称）中，职工号-&gt;姓名，职工号-&gt;职称，而项目号-&amp;gt">
<meta property="og:locale" content="zh_CN">
<meta property="og:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/innodb.jpg">
<meta property="og:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/myisam.jpg">
<meta property="og:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/b-tree.png">
<meta property="og:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/b+tree.png">
<meta property="og:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/b+tree_keys.png">
<meta property="og:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/mvvc.png">
<meta property="article:published_time" content="2020-04-08T16:22:23.000Z">
<meta property="article:modified_time" content="2020-04-15T15:23:18.867Z">
<meta property="article:author" content="HitoMeng">
<meta property="article:tag" content="sql">
<meta property="article:tag" content="事务">
<meta name="twitter:card" content="summary">
<meta name="twitter:image" content="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/innodb.jpg">



<script type="text/javascript" id="hexo.configurations">
  var NexT = window.NexT || {};
  var CONFIG = {
    root: '/java-notes/',
    scheme: 'Gemini',
    version: '5.1.4',
    sidebar: {"position":"left","display":"post","offset":12,"b2t":false,"scrollpercent":false,"onmobile":false},
    fancybox: true,
    tabs: true,
    motion: {"enable":true,"async":false,"transition":{"post_block":"fadeIn","post_header":"slideDownIn","post_body":"slideDownIn","coll_header":"slideLeftIn","sidebar":"slideUpIn"}},
    duoshuo: {
      userId: '0',
      author: 'Author'
    },
    algolia: {
      applicationID: '',
      apiKey: '',
      indexName: '',
      hits: {"per_page":10},
      labels: {"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}
    }
  };
</script>



  <link rel="canonical" href="https://hitomeng.gitee.io/2020/04/09/MySQL知识点/"/>





  <title>MySQL知识点 | JavaNote</title>
  








<meta name="generator" content="Hexo 4.2.0"></head>

<body itemscope itemtype="http://schema.org/WebPage" lang="zh-CN">

  
  
    
  

  <div class="container sidebar-position-left page-post-detail">
    <div class="headband"></div>

    <header id="header" class="header" itemscope itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-wrapper">
  <div class="site-meta ">
    

    <div class="custom-logo-site-title">
      <a href="/java-notes/"  class="brand" rel="start">
        <span class="logo-line-before"><i></i></span>
        <span class="site-title">JavaNote</span>
        <span class="logo-line-after"><i></i></span>
      </a>
    </div>
      
        <p class="site-subtitle">To be a better developer!</p>
      
  </div>

  <div class="site-nav-toggle">
    <button>
      <span class="btn-bar"></span>
      <span class="btn-bar"></span>
      <span class="btn-bar"></span>
    </button>
  </div>
</div>

<nav class="site-nav">
  

  
    <ul id="menu" class="menu">
      
        
        <li class="menu-item menu-item-home">
          <a href="/java-notes/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-home"></i> <br />
            
            Home
          </a>
        </li>
      
        
        <li class="menu-item menu-item-categories">
          <a href="/java-notes/categories/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-th"></i> <br />
            
            Categories
          </a>
        </li>
      
        
        <li class="menu-item menu-item-tags">
          <a href="/java-notes/tags/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-tags"></i> <br />
            
            Tags
          </a>
        </li>
      
        
        <li class="menu-item menu-item-archives">
          <a href="/java-notes/archives/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-archive"></i> <br />
            
            Archives
          </a>
        </li>
      
        
        <li class="menu-item menu-item-about">
          <a href="/java-notes/about/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-user"></i> <br />
            
            About
          </a>
        </li>
      

      
    </ul>
  

  
</nav>



 </div>
    </header>

    <main id="main" class="main">
      <div class="main-inner">
        <div class="content-wrap">
          <div id="content" class="content">
            

  <div id="posts" class="posts-expand">
    

  

  
  
  

  <article class="post post-type-normal" itemscope itemtype="http://schema.org/Article">
  
  
  
  <div class="post-block">
    <link itemprop="mainEntityOfPage" href="https://hitomeng.gitee.io/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="name" content="HitoMeng">
      <meta itemprop="description" content="">
      <meta itemprop="image" content="/java-notes/images/avatar.gif">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="JavaNote">
    </span>

    
      <header class="post-header">

        
        
          <h1 class="post-title" itemprop="name headline">MySQL知识点</h1>
        

        <div class="post-meta">
          <span class="post-time">
            
              <span class="post-meta-item-icon">
                <i class="fa fa-calendar-o"></i>
              </span>
              
                <span class="post-meta-item-text">Posted on</span>
              
              <time title="Post created" itemprop="dateCreated datePublished" datetime="2020-04-09T00:22:23+08:00">
                2020-04-09
              </time>
            

            

            
          </span>

          
            <span class="post-category" >
            
              <span class="post-meta-divider">|</span>
            
              <span class="post-meta-item-icon">
                <i class="fa fa-folder-o"></i>
              </span>
              
                <span class="post-meta-item-text">In</span>
              
              
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/java-notes/categories/database/" itemprop="url" rel="index">
                    <span itemprop="name">database</span>
                  </a>
                </span>

                
                
              
            </span>
          

          
            
          

          
          

          

          

          

        </div>
      </header>
    

    
    
    
    <div class="post-body" itemprop="articleBody">

      
      

      
        <h1 id="MySql"><a href="#MySql" class="headerlink" title="MySql"></a>MySql</h1><h2 id="数据库设计范式"><a href="#数据库设计范式" class="headerlink" title="数据库设计范式"></a>数据库设计范式</h2><ul>
<li><p><strong>第一范式（1NF）：要求数据库表的每一列都是不可分割的原子数据项。</strong> 某列是地址，其实为了满足第一范式的话还是可以继续分割成省市区列。</p>
</li>
<li><p><strong>第二范式（2NF</strong> ）： <strong>在1NF的基础上，非码属性必须完全依赖于候选码（在1NF基础上消除非主属性对主码的部分函数依赖）</strong> </p>
<p>如关系模型（职工号，姓名，职称，项目号，项目名称）中，职工号-&gt;姓名，职工号-&gt;职称，而项目号-&gt;项目名称。显然依赖关系不满足第二范式，常用的解决办法是差分表格，比如拆分为职工信息表和项目信息表。 </p>
</li>
<li><p><strong>第三范式（3NF）：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）</strong> </p>
<p><a href="https://www.zhihu.com/question/24696366" target="_blank" rel="noopener">知乎解释</a></p>
</li>
</ul>
<a id="more"></a>

<h2 id="存储引擎"><a href="#存储引擎" class="headerlink" title="存储引擎"></a>存储引擎</h2><p><strong>常见的存储引擎及其区别</strong></p>
<ul>
<li><p>InnoDB：MySql默认的存储引擎，设计目标是面向在线事务处理的应用。</p>
<ul>
<li>特点是行锁设计、支持外键；</li>
<li>B+索引</li>
<li>通过多版本并发控制来获得高并发性，提供插入缓存、二次写、自适用哈希索引和预读等高可用功能。</li>
<li>并且实现了SQL的四种隔离级别，默认为<strong>REPEATABLE</strong>级别。</li>
<li>对于表中的数据存储使用了聚集(clustered)方式，因此每张表都是按主键的顺序存放，如果没有设置主键，InnoDB会为每一行生成ROWID，并以此作为主键。</li>
</ul>
<img src="/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/innodb.jpg" class title="innodb"> 
</li>
<li><p>MyISAM：支持全文索引，主要面向查询服务的应用。<strong><em>MySQL5.7开始InnoDB已经支持全文索引，而且效果更好</em></strong></p>
<ul>
<li>不支持事务。不是所有应用都需要事务支持，只是查询操作。</li>
<li>B+索引</li>
<li>表锁设计、<strong>不支持外键</strong></li>
<li>只缓存索引文件，而不缓存数据文件，这点和大多数数据库都不同</li>
</ul>
<img src="/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/myisam.jpg" class title="innodb">  
</li>
<li><p>Memory：表中数据存储在内存中，重启数据全部消失，适合存储临时表，使用Hash索引而不是B+索引。那为什么不使用这个代替Redis？Redis是为了MySQL减负的，而且数据易丢失不保证可用，需要手动持久化。</p>
</li>
</ul>
<p><strong>InnoDB是如何实现RR（可重复读）的？</strong></p>
<p><strong>InnoDB为什么推荐使用自增ID作为主键</strong></p>
<p>自增ID可以保证每次插入时B+索引是从右边扩展的，可以避免B+树和频繁合并和分裂（对比使用UUID）。如果使用字符串主键和随机主键，会使得数据随机插入，效率比较差。</p>
<h2 id="索引"><a href="#索引" class="headerlink" title="索引"></a>索引</h2><h3 id="数据结构"><a href="#数据结构" class="headerlink" title="数据结构"></a>数据结构</h3><p><strong>二叉查找树</strong></p>
<p>一棵二叉树中，左子树的键值总是小于根节点，右子树的键值总是大于根节点，因此可以通过中序遍历获取键值的排序输出。但是如果源数列已经是有序的，构建的二叉查找树就会变成高度与数列长度相同的树，查找效率降为o(n)，为此引入平衡二叉树。</p>
<p><strong>平衡二叉树</strong></p>
<p>在二叉排序树的基础上，限制树的左右两个子树的<strong>高度差不大于1.</strong>平衡二叉树的查找性能是比较高的，但是最优二叉树的建立和维护需要大量的操作。</p>
<p><strong>B树</strong></p>
<ol>
<li>平衡二叉树节点最多有两个子树，而 B 树每个节点可以有多个子树，M 阶 B 树表示该树每个节点最多有 M 个子树 </li>
<li>平衡二叉树每个节点只有一个数据和两个指向孩子的指针，而 B 树每个中间节点有 k-1 个关键字（可以理解为数据）和 k 个子树 （ k 介于阶数 M 和 M/2 之间，M/2 向上取整 ）</li>
<li>B 树的所有叶子节点都在同一层，并且叶子节点只有关键字，指向孩子的指针为 null </li>
<li>和平衡二叉树相同的点在于：B 树的节点数据大小也是按照左小右大，子树与节点的大小比较决定了子树指针所处位置 </li>
</ol>
<img src="/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/b-tree.png" class title="b-tree">

<p>   <strong>B 树的每个节点可以表示的信息更多，因此整个树更加“矮胖”，这在从磁盘中查找数据（先读取到内存、后查找）的过程中，可以减少磁盘 IO 的次数，从而提升查找速度</strong> 。</p>
<p><strong>B+树</strong></p>
<ol>
<li>节点的子树数和关键字数相同，（B 树是关键字数比子树数少一）  </li>
<li>节点的关键字表示的是子树中的最大数，在子树中同样含有这个数据。根节点键值就是最大值。B树不允许键重复。</li>
<li>叶子节点包含了全部数据，同时符合左小右大的顺序 </li>
</ol>
<img src="/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/b+tree.png" class title="b-tree">

<p>相较于B树有什么优点？</p>
<ol>
<li>B+中间节点只保存指针，相较于B树中间节点保存指针和记录， 可以大大增加每个节点存储的 key 值的数量，降低 B+ 树的高度。</li>
<li>所有记录都保存在叶子节点，查找效率稳定</li>
<li>叶子节点之间有指针相连，数据遍历时只需要对叶子节点遍历即可，B+非常适合范围查找</li>
</ol>
<p><strong>那为什么MongoDB还选择用B树作为索引结构呢？</strong></p>
<p>综上可以发现B+最大的好处就是范围查找和遍历操作，MongoDB作为非关系型数据库期望单个Collection的设计和查询就能满足需求，不涉及多表操作，如果你的MongoDB频繁使用lookup，那就需要重写审视Collection的设计。MySQL是关系型数据库，很多情况下表与表之间存在很强的关系，<strong>join操作十分常见。</strong>而join操作就不可避免的需要遍历所有记录，而B+树能很好的支持遍历操作。</p>
<p><strong><a href="https://blog.csdn.net/sinat_41917109/article/details/88944290" target="_blank" rel="noopener">InnoDB索引最左匹配原则</a></strong></p>
<p> 索引的底层是一颗B+树，那么联合索引当然还是一颗B+树，只不过联合索引的健值数量不是一个，而是多个。构建一颗B+树只能根据一个值来构建，因此数据库依据联合索引最左的字段来构建B+树。<br>例子：假如创建一个（a,b)的联合索引，那么它的索引树是这样的 </p>
<img src="/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/b+tree_keys.png" class title="b+tree_keys">


<p>可以看到a的值是有顺序的，1，1，2，2，3，3，而b的值是没有顺序的1，2，1，4，1，2。所以b = 2这种查询条件没有办法利用索引，因为联合索引首先是按a排序的，b是无序的。</p>
<p>同时我们还可以发现在a值相等的情况下，b值又是按顺序排列的，但是这种顺序是相对的。所以最左匹配原则遇上范围查询就会停止，剩下的字段都无法使用索引。例如a = 1 and b = 2 a,b字段都可以使用索引，因为在a值确定的情况下b是相对有序的，而a&gt;1and b=2，a字段可以匹配上索引，但b值不可以，因为a的值是一个范围，在这个范围中b是无序的。</p>
<p>最左匹配原则：最左优先，以最左边的为起点任何连续的索引都能匹配上。同时遇到范围查询(&gt;、&lt;、between、like)就会停止匹配。</p>
<p> 假如建立联合索引（a,b,c）</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"># 用到了索引 where子句几个搜索条件顺序调换不影响查询结果，因为Mysql中有查询优化器，会自动优化查询顺序</span><br><span class="line">select * from table_name where a &#x3D; &#39;1&#39; and b &#x3D; &#39;2&#39; and c &#x3D; &#39;3&#39; </span><br><span class="line">select * from table_name where b &#x3D; &#39;2&#39; and a &#x3D; &#39;1&#39; and c &#x3D; &#39;3&#39;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"># 都从最左边开始连续匹配，用到了索引</span><br><span class="line">select * from table_name where a &#x3D; &#39;1&#39; </span><br><span class="line">select * from table_name where a &#x3D; &#39;1&#39; and b &#x3D; &#39;2&#39;  </span><br><span class="line">select * from table_name where a &#x3D; &#39;1&#39; and b &#x3D; &#39;2&#39; and c &#x3D; &#39;3&#39;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"># 没有从最左边开始，最后查询没有用到索引，用的是全表扫描 </span><br><span class="line">select * from table_name where  b &#x3D; &#39;2&#39; </span><br><span class="line">select * from table_name where  c &#x3D; &#39;3&#39;</span><br><span class="line">select * from table_name where  b &#x3D; &#39;1&#39; and c &#x3D; &#39;3&#39;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># 不连续时，只用到了a列的索引，b列和c列都没有用到 </span><br><span class="line">select * from table_name where a &#x3D; &#39;1&#39; and c &#x3D; &#39;3&#39;</span><br></pre></td></tr></table></figure>

<p><strong>匹配列前缀</strong></p>
<p>如果列是字符型的话它的比较规则是先比较字符串的第一个字符，第一个字符小的哪个字符串就比较小，如果两个字符串第一个字符相通，那就再比较第二个字符，第二个字符比较小的那个字符串就比较小，依次类推，比较字符串。</p>
<p>如果a是字符类型，那么前缀匹配用的是索引，后缀和中缀只能全表扫描了</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">select * from table_name where a like &#39;As%&#39;; &#x2F;&#x2F;前缀都是排好序的，走索引查询</span><br><span class="line">select * from table_name where  a like &#39;%As&#39;&#x2F;&#x2F;全表查询</span><br><span class="line">select * from table_name where  a like &#39;%As%&#39;&#x2F;&#x2F;全表查询</span><br></pre></td></tr></table></figure>

<p> <strong>匹配范围值</strong> </p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># 可以对最左边的列进行范围查询</span><br><span class="line">select * from table_name where  a &gt; 1 and a &lt; 3</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># 个列同时进行范围查找时，只有对索引最左边的那个列进行范围查找才用到B+树索引，也就是只有a用到索引，在1&lt;a&lt;3的范围内b是无序的，不能用索引，找到1&lt;a&lt;3的记录后，只能根据条件 b &gt; 1继续逐条过滤</span><br><span class="line">select * from table_name where  a &gt; 1 and a &lt; 3 and b &gt; 1;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># 左边的列是精确查找的，右边的列可以进行范围查找,a&#x3D;1的情况下b是有序的，进行范围查找走的是联合索引</span><br><span class="line">select * from table_name where  a &#x3D; 1 and b &gt; 3;</span><br></pre></td></tr></table></figure>

<p> <strong>排序</strong> </p>
<p>一般情况下，我们只能把记录加载到内存中，再用一些排序算法，比如快速排序，归并排序等在内存中对这些记录进行排序，有时候查询的结果集太大不能在内存中进行排序的话，还可能暂时借助磁盘空间存放中间结果，排序操作完成后再把排好序的结果返回客户端。Mysql中把这种再内存中或磁盘上进行排序的方式统称为文件排序。文件排序非常慢，但如果order子句用到了索引列，就有可能省去文件排序的步骤</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># b+树索引本身就是按照上述规则排序的，所以可以直接从索引中提取数据，然后进行回表操作取出该索引中不包含的列就好了order by的子句后面的顺序也必须按照索引列的顺序给出，比如</span><br><span class="line">select * from table_name order by a,b,c limit 10;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># 这种颠倒顺序的没有用到索引</span><br><span class="line">select * from table_name order by b,c,a limit 10;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"># 联合索引左边列为常量，后边的列排序可以用到索引</span><br><span class="line">select * from table_name where a &#x3D;1 order by b,c limit 10;</span><br></pre></td></tr></table></figure>

<h3 id="索引类型"><a href="#索引类型" class="headerlink" title="索引类型"></a>索引类型</h3><p>索引类型针对的是字段</p>
<ul>
<li>FULLTEXT 全文索引，类似倒排索引</li>
<li>NORMAL  仅加速查询 </li>
<li>UNIQUE   索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。 </li>
<li>SPATIAL   对 空间数据类型的字段建立的索引，MYSQL中的空间数据类型有4种，分别是GEOMETRY、POINT、LINESTRING、POLYGON </li>
</ul>
<h3 id="索引方法"><a href="#索引方法" class="headerlink" title="索引方法"></a>索引方法</h3><p>索引方法即实现索引的方法</p>
<ul>
<li>B+树：</li>
<li>Hash索引，MySQL采用链表法处理Hash冲突。<ul>
<li>Hash索引仅仅能满足”=”,”IN”和”&lt;=&gt;(安全等于)”查询，不能使用范围查询 </li>
<li>Hash索引无法被用来避免数据的排序操作。因为Hash值的大小关系并不一定和Hash运算前的键值完全一样 </li>
<li>Hash索引不能利用部分索引键查询。对于组合索引，Hash索引在计算Hash值的时候是组合索引键合并后再一起计算Hash值，而不是单独计算Hash值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash索引也无法被利用 </li>
<li>Hash索引遇到大量Hash值相等的情况后性能并不一定就会比B+树索引高 </li>
</ul>
</li>
</ul>
<h2 id="锁"><a href="#锁" class="headerlink" title="锁"></a>锁</h2><p>锁机制用于管理对共享资源的并发访问</p>
<h3 id="InnoDB中的锁"><a href="#InnoDB中的锁" class="headerlink" title="InnoDB中的锁"></a>InnoDB中的锁</h3><h4 id="锁的类型"><a href="#锁的类型" class="headerlink" title="锁的类型"></a>锁的类型</h4><p><strong>按粒度分为：</strong></p>
<ol>
<li><p>表锁： mysql锁中粒度最大的一种锁，表示当前的操作对整张表加锁，资源开销比行锁少（实现逻辑简单），不会出现死锁的情况，但是发生锁冲突的概率很大。 </p>
</li>
<li><p>行锁： 行锁的是mysql锁中粒度最小的一种锁，因为锁的粒度很小，所以发生资源争抢的概率也最小，并发性能最大，但是也会造成死锁，每次加锁和释放锁的开销也会变大。 </p>
<p>InnoDB实现了两种标准的行级锁：</p>
<ul>
<li>共享锁（S锁）： 若事务A对数据对象1加上S锁，则事务A可以读数据对象1但不能修改，其他事务只能再对数据对象1加S锁，而不能加X锁，直到事务A释放数据对象1上的S锁。这保证了其他事务可以读数据对象1，但在事务A释放数据对象1上的S锁之前不能对数据对象1做任何修改。 </li>
<li>排他锁（X锁）： 若事务A对数据对象1加上X锁，事务A可以读数据对象1也可以修改数据对象1，其他事务不能再对数据对象1加任何锁，直到事务A释放数据对象1上的锁。这保证了其他事务在事务A释放数据对象1上的锁之前不能再读取和修改数据对象1。 </li>
</ul>
<table>
<thead>
<tr>
<th align="center"></th>
<th align="center">X</th>
<th align="center">S</th>
</tr>
</thead>
<tbody><tr>
<td align="center">X</td>
<td align="center">不兼容</td>
<td align="center">不兼容</td>
</tr>
<tr>
<td align="center">S</td>
<td align="center">不兼容</td>
<td align="center">兼容</td>
</tr>
</tbody></table>
</li>
</ol>
<p><strong>为解决不同粒度决锁共存问题，引入意向锁</strong></p>
<p>意向共享锁（IS）：事务想要在获得表中某些记录的共享锁，需要在表上先加意向共享锁。</p>
<p>意向互斥锁（IX）：事务想要在获得表中某些记录的互斥锁，需要在表上先加意向互斥锁。</p>
<p>意向锁是<strong>表级别锁</strong>。 当我们需要给一个加表锁的时候，我们需要根据意向锁去判断表中有没有数据行被锁定，以确定是否能加成功。如果意向锁是行锁，那么我们就得遍历表中所有数据行来判断。如果意向锁是表锁，则我们直接判断一次就知道表中是否有数据行被锁定了。所以说将意向锁设置成表级别的锁的性能比行锁高的多。 </p>
<p>作用就是：  当一个事务在需要获取资源的锁定时，如果该资源已经被排他锁占用，则数据库会自动给该事务申请一个该表的意向锁。如果自己需要一个共享锁定，就申请一个意向共享锁。如果需要的是某行（或者某些行）的排他锁定，则申请一个意向排他锁。 </p>
<table>
<thead>
<tr>
<th></th>
<th>IS</th>
<th>IX</th>
<th>S</th>
<th>X</th>
</tr>
</thead>
<tbody><tr>
<td>IS</td>
<td>兼容</td>
<td>兼容</td>
<td>兼容</td>
<td>不兼容</td>
</tr>
<tr>
<td>IX</td>
<td>兼容</td>
<td>兼容</td>
<td>不兼容</td>
<td>不兼容</td>
</tr>
<tr>
<td>S</td>
<td>兼容</td>
<td>不兼容</td>
<td>兼容</td>
<td>不兼容</td>
</tr>
<tr>
<td>X</td>
<td>不兼容</td>
<td>不兼容</td>
<td>不兼容</td>
<td>不兼容</td>
</tr>
</tbody></table>
<p>从表中可以发现：</p>
<ul>
<li>意向锁之间是兼容的</li>
<li>意向锁和非意向锁之间的兼容性与行锁之间一致。IS-X=S-X</li>
<li>意向锁不会阻塞全表扫以外的任何请求</li>
</ul>
<h4 id="一致性非锁定读"><a href="#一致性非锁定读" class="headerlink" title="一致性非锁定读"></a>一致性非锁定读</h4><blockquote>
<p>MySQL如何做到读写并行？多版本并发控制(Multi Version Concurrency Control, MVVC)</p>
</blockquote>
<p>一致性的非锁定读是指<strong>InnoDB存储引擎通过多版本控制方法来读取当前执行时间数据库中行的数据。</strong>之所以叫做非锁定读，因为不需要等待行锁X的释放。</p>
<img src="/java-notes/2020/04/09/MySQL%E7%9F%A5%E8%AF%86%E7%82%B9/mvvc.png" class title="mvvc">

<p>快照数据是该行的之前版本数据，实现是通过undo段完成。undo用来回滚事务，因此快照数据本身是没有额外开销的。既然是历史数据，到底读取哪个时间点的数据呢？</p>
<ol>
<li>RC模式下，读取最新的快照。因为可以读其他事务的提交，期望尽可能新。</li>
<li>RR模式下，读取<strong>当前事务</strong>开始时的快照。可重复读，认为读取开始时的快照能满足要求。</li>
</ol>
<h4 id="一致性锁定读"><a href="#一致性锁定读" class="headerlink" title="一致性锁定读"></a>一致性锁定读</h4><p>显示地对读操作加锁</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">SELECT ... FOR UPDATE</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">SELECT ... LOCK IN SHARE MODE</span><br></pre></td></tr></table></figure>

<h3 id="锁的算法"><a href="#锁的算法" class="headerlink" title="锁的算法"></a>锁的算法</h3><p>InnoDB有三种行锁的算法：</p>
<ul>
<li>Record Lock：单个行记录上的锁。</li>
<li>Gap Lock：间隙锁，锁定一个范围，但不包含记录本身</li>
<li>Next-Key Lock：Gap Lock + Record Lock，锁定一个范围并且锁定记录本身</li>
</ul>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">CREATE TABLE z( a INT, b INT, PRIMARY KEY(a), KEY(B));</span><br><span class="line">INSERT INTO z SELECT 1,1;</span><br><span class="line">INSERT INTO z SELECT 3,1;</span><br><span class="line">INSERT INTO z SELECT 5,3;</span><br><span class="line">INSERT INTO z SELECT 7,6;</span><br><span class="line">INSERT INTO z SELECT 10,8;</span><br></pre></td></tr></table></figure>

<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"># 事务A执行以下语句</span><br><span class="line">SELECT * FROM z WHERE b&#x3D;3 FOR UPDATE;# b对应的a列加RecordLock，b因为是辅助索引加Next-key lock</span><br><span class="line"></span><br><span class="line"># 事务B运行下面的语句</span><br><span class="line">SELECT * FROM z WHERE a &#x3D; 5 LOCK IN SHARE MODE; # 显然阻塞，因为A中b&#x3D;3对应的a&#x3D;5行已经被锁定</span><br><span class="line">INSERT INTO z SELECT 4,2; # 还是阻塞。主键不阻塞，但是辅助索引因为next-key lock (1,3)(3,6)两个范围都被锁定了</span><br><span class="line">INSERT INTO z SELECT 6,5;# 阻塞。理由同上</span><br><span class="line"></span><br><span class="line">INSERT INTO z SELECT 2,0;# 立即执行。主键和辅助索引都没有被锁</span><br></pre></td></tr></table></figure>

<p>通过以上语句可以发现，Gap Lock的作用就是阻止多个事务将记录插入到同一范围。</p>
<p><strong>那next-key lock什么时候使用Record Lock？</strong></p>
<p>对于唯一键值的锁定，Next-Key Lock降级为Record Lock仅存在于<strong>查询所有的唯一索引列。</strong>若唯一索引由多个列组成，而查询仅是查询多列中的其中一个，那么查询是Range查询，故仍使用Next-Key Lock进行锁定。</p>
<p><strong>MySQL在RR隔离级别就能解决幻读，如何实现的？</strong></p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"># 表t主键为a列</span><br><span class="line"># 事务A</span><br><span class="line">BEGIN</span><br><span class="line">SELECT * FROM t WHERE a &gt; 2 FOR UPDATE</span><br><span class="line">COMMIT</span><br><span class="line"># 事务B</span><br><span class="line">BEGIN</span><br><span class="line">INSERT INTO t SELECT 4;</span><br><span class="line">COMMIT</span><br></pre></td></tr></table></figure>

<p>在RR级别下，A-&gt;B-&gt;A 发生幻读。但是InnoDB会对(2,+∞)范围加X锁，事务B是无法插入的，解决了幻读（<strong>同一事务下，连续执行两次相同的SQL语句可能导致不同的结果，第二次SQL可能返回之前不存在的行</strong>）问题。</p>
<h3 id="死锁"><a href="#死锁" class="headerlink" title="死锁"></a>死锁</h3><p>死锁是指两个或两个以上的事务在执行过程中，因争夺锁资源而造成的一种相互等待的现象。如无外力作用，事务都将无法进行下去。</p>
<h4 id="案例"><a href="#案例" class="headerlink" title="案例"></a>案例</h4><blockquote>
<p>id为主键 token辅助索引</p>
</blockquote>
<ol>
<li><p>不同表相同记录行锁冲突</p>
<table>
<thead>
<tr>
<th>事务A</th>
<th>事务B</th>
</tr>
</thead>
<tbody><tr>
<td>delete from table_1 where id = 1;</td>
<td></td>
</tr>
<tr>
<td></td>
<td>udpate msg set message=’订单’ where token = ‘asd’;</td>
</tr>
<tr>
<td>update msg set message=’订单’ where token = ‘asd’;</td>
<td></td>
</tr>
<tr>
<td></td>
<td>delete from table_1 where id = 1;</td>
</tr>
</tbody></table>
</li>
<li><p>相同表记录行锁冲突</p>
<table>
<thead>
<tr>
<th>事务A</th>
<th>事务B</th>
</tr>
</thead>
<tbody><tr>
<td>update from table_1 where id = 1;</td>
<td></td>
</tr>
<tr>
<td></td>
<td>update form table_1 where id = 2;</td>
</tr>
<tr>
<td>update from table_1 where id = 2;</td>
<td></td>
</tr>
<tr>
<td></td>
<td>update from table_1 where id = 1;</td>
</tr>
</tbody></table>
</li>
</ol>
<h4 id="MySQL如何解决死锁问题"><a href="#MySQL如何解决死锁问题" class="headerlink" title="MySQL如何解决死锁问题"></a>MySQL如何解决死锁问题</h4><ol>
<li>最简单的办法，超时回滚。当两个事务相互等待时，当一个等待时间超过设定阈值，其中一个事务回滚，另一个等待事务就能继续运行。仅仅超时处理，那么回滚的总是先开始事务的那个，如果该事务操作复杂，回滚占用很多undo log，显然是不合理的。</li>
<li>wait-for graph（等待图）事务之间的资源请求关系用一张有向图来表示，如果图中出现回路就存在死锁。InnoDB会选择回滚undo量最小的事务。</li>
</ol>
<h4 id="Developer如何避免死锁"><a href="#Developer如何避免死锁" class="headerlink" title="Developer如何避免死锁"></a>Developer如何避免死锁</h4><ol>
<li>以固定的顺序访问表和行。案例2中两个事务都按照{1,2}顺序就不会发生死锁</li>
<li>大事务拆成小事务。大事务更倾向于死锁，如果业务允许，将大事务拆小</li>
<li>同一个事务中，尽可能做到一次锁定所需的所有资源</li>
<li>为表添加合理的索引。可以看到如果不走索引将会为表的每一行记录添加上锁，死锁的概率大大增大</li>
</ol>
<h2 id="MySQL事务"><a href="#MySQL事务" class="headerlink" title="MySQL事务"></a>MySQL事务</h2><h3 id="事务特性"><a href="#事务特性" class="headerlink" title="事务特性"></a>事务特性</h3><p>事务是访问数据库的一个操作序列，保证了用户的每一次操作都是可靠的，即使出现了异常情况，也不会破坏后台数据的完整性。这就要求事务满足以下四个特性：ACID</p>
<ul>
<li>Automic：原子性。事务是不可分割的工作单位，要么都做要么都不做。</li>
<li>Consistency：一致性。事务将数据库从一种状态转换到另一种一致状态。事务开始之前和之后，数据库的完整性约束没有被打破。例如事务在失败回滚时，不能在唯一列插入重复值</li>
<li>Isolation：隔离性。事务提交前，对其他事务不可见</li>
<li>durability：持久性。事务一旦提交成功，其结果是永久性的。即使宕机或其他故障也是能恢复的。</li>
</ul>
<h3 id="控制语句"><a href="#控制语句" class="headerlink" title="控制语句"></a>控制语句</h3><ul>
<li><strong>BEGIN</strong> 开始一个事务</li>
<li><strong>ROLLBACK</strong> 事务回滚</li>
<li><strong>COMMIT</strong> 事务确认</li>
</ul>
<h3 id="并发一致性问题"><a href="#并发一致性问题" class="headerlink" title="并发一致性问题"></a>并发一致性问题</h3><ol>
<li><strong>更新丢失</strong>：后一个事务覆盖前一个事务的结果。<ol>
<li>事务1将行r更新为v1，但未提交</li>
<li>事务2将行r更新为v2，但未提交</li>
<li>事务1提交</li>
<li>事务2提交</li>
</ol>
</li>
<li><strong>脏读</strong>： 事务B读取到了事务A已修改但尚未提交的的数据。脏读隔离看似毫无用处，但是在不需要精确性的查询时，可以大大提高性能</li>
<li><strong>不可重复读</strong>：在一个事务内，多次读同一个数据。在这个事务还没有结束时，另一个事务也访问该同一数据。那么，在第一个事务的两次读数据之间。由于第二个事务的修改，那么第一个事务读到的数据可能不一样，这样就发生了在一个事务内两次读到的数据是不一样的，因此称为不可重复读，即原始读取不可重复。 <strong>一个事务范围内两个相同的查询却返回了不同数据</strong> </li>
<li><strong>幻读：</strong> 一个事务T1按相同的查询条件重新读取以前检索过的数据，却发现其他事务T2插入了满足其查询条件的新数据，这种现象就称为“幻读” </li>
</ol>
<h4 id="数据库提供一定的隔离级别解决上述问题"><a href="#数据库提供一定的隔离级别解决上述问题" class="headerlink" title="数据库提供一定的隔离级别解决上述问题"></a>数据库提供一定的隔离级别解决上述问题</h4><table>
<thead>
<tr>
<th align="center">隔离级别</th>
<th align="center">读数据一致性</th>
<th align="center">脏读</th>
<th align="center">不可重复读</th>
<th align="center">幻读</th>
</tr>
</thead>
<tbody><tr>
<td align="center">Read Uncommitted</td>
<td align="center">最低级别</td>
<td align="center">Y</td>
<td align="center">Y</td>
<td align="center">Y</td>
</tr>
<tr>
<td align="center">Read Committed</td>
<td align="center">语句级</td>
<td align="center">X</td>
<td align="center">Y</td>
<td align="center">Y</td>
</tr>
<tr>
<td align="center">Reapeatable Read</td>
<td align="center">事务级</td>
<td align="center">X</td>
<td align="center">X</td>
<td align="center">Y</td>
</tr>
<tr>
<td align="center">Serializable</td>
<td align="center">最好级别，事务级</td>
<td align="center">X</td>
<td align="center">X</td>
<td align="center">X</td>
</tr>
</tbody></table>
<h2 id="常见面试题"><a href="#常见面试题" class="headerlink" title="常见面试题"></a>常见面试题</h2>
      
    </div>
    
    
    

    

    

    

    <footer class="post-footer">
      
        <div class="post-tags">
          
            <a href="/java-notes/tags/sql/" rel="tag"># sql</a>
          
            <a href="/java-notes/tags/%E4%BA%8B%E5%8A%A1/" rel="tag"># 事务</a>
          
        </div>
      

      
      
      

      
        <div class="post-nav">
          <div class="post-nav-next post-nav-item">
            
              <a href="/java-notes/2020/04/05/hello-world/" rel="next" title="Hello World">
                <i class="fa fa-chevron-left"></i> Hello World
              </a>
            
          </div>

          <span class="post-nav-divider"></span>

          <div class="post-nav-prev post-nav-item">
            
              <a href="/java-notes/2020/04/10/sql%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/" rel="prev" title="sql必知必会">
                sql必知必会 <i class="fa fa-chevron-right"></i>
              </a>
            
          </div>
        </div>
      

      
      
    </footer>
  </div>
  
  
  
  </article>



    <div class="post-spread">
      
    </div>
  </div>


          </div>
          


          

  



        </div>
        
          
  
  <div class="sidebar-toggle">
    <div class="sidebar-toggle-line-wrap">
      <span class="sidebar-toggle-line sidebar-toggle-line-first"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-middle"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-last"></span>
    </div>
  </div>

  <aside id="sidebar" class="sidebar">
    
    <div class="sidebar-inner">

      

      
        <ul class="sidebar-nav motion-element">
          <li class="sidebar-nav-toc sidebar-nav-active" data-target="post-toc-wrap">
            Table of Contents
          </li>
          <li class="sidebar-nav-overview" data-target="site-overview-wrap">
            Overview
          </li>
        </ul>
      

      <section class="site-overview-wrap sidebar-panel">
        <div class="site-overview">
          <div class="site-author motion-element" itemprop="author" itemscope itemtype="http://schema.org/Person">
            
              <p class="site-author-name" itemprop="name">HitoMeng</p>
              <p class="site-description motion-element" itemprop="description">You do have the time!</p>
          </div>

          <nav class="site-state motion-element">

            
              <div class="site-state-item site-state-posts">
              
                <a href="/java-notes/archives/%7C%7Carchive">
              
                  <span class="site-state-item-count">7</span>
                  <span class="site-state-item-name">posts</span>
                </a>
              </div>
            

            
              
              
              <div class="site-state-item site-state-categories">
                <a href="/java-notes/categories/index.html">
                  <span class="site-state-item-count">3</span>
                  <span class="site-state-item-name">categories</span>
                </a>
              </div>
            

            
              
              
              <div class="site-state-item site-state-tags">
                <a href="/java-notes/tags/index.html">
                  <span class="site-state-item-count">8</span>
                  <span class="site-state-item-name">tags</span>
                </a>
              </div>
            

          </nav>

          

          

          
          

          
          

          

        </div>
      </section>

      
      <!--noindex-->
        <section class="post-toc-wrap motion-element sidebar-panel sidebar-panel-active">
          <div class="post-toc">

            
              
            

            
              <div class="post-toc-content"><ol class="nav"><li class="nav-item nav-level-1"><a class="nav-link" href="#MySql"><span class="nav-number">1.</span> <span class="nav-text">MySql</span></a><ol class="nav-child"><li class="nav-item nav-level-2"><a class="nav-link" href="#数据库设计范式"><span class="nav-number">1.1.</span> <span class="nav-text">数据库设计范式</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#存储引擎"><span class="nav-number">1.2.</span> <span class="nav-text">存储引擎</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#索引"><span class="nav-number">1.3.</span> <span class="nav-text">索引</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#数据结构"><span class="nav-number">1.3.1.</span> <span class="nav-text">数据结构</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#索引类型"><span class="nav-number">1.3.2.</span> <span class="nav-text">索引类型</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#索引方法"><span class="nav-number">1.3.3.</span> <span class="nav-text">索引方法</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#锁"><span class="nav-number">1.4.</span> <span class="nav-text">锁</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#InnoDB中的锁"><span class="nav-number">1.4.1.</span> <span class="nav-text">InnoDB中的锁</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#锁的类型"><span class="nav-number">1.4.1.1.</span> <span class="nav-text">锁的类型</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#一致性非锁定读"><span class="nav-number">1.4.1.2.</span> <span class="nav-text">一致性非锁定读</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#一致性锁定读"><span class="nav-number">1.4.1.3.</span> <span class="nav-text">一致性锁定读</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#锁的算法"><span class="nav-number">1.4.2.</span> <span class="nav-text">锁的算法</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#死锁"><span class="nav-number">1.4.3.</span> <span class="nav-text">死锁</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#案例"><span class="nav-number">1.4.3.1.</span> <span class="nav-text">案例</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#MySQL如何解决死锁问题"><span class="nav-number">1.4.3.2.</span> <span class="nav-text">MySQL如何解决死锁问题</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#Developer如何避免死锁"><span class="nav-number">1.4.3.3.</span> <span class="nav-text">Developer如何避免死锁</span></a></li></ol></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#MySQL事务"><span class="nav-number">1.5.</span> <span class="nav-text">MySQL事务</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#事务特性"><span class="nav-number">1.5.1.</span> <span class="nav-text">事务特性</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#控制语句"><span class="nav-number">1.5.2.</span> <span class="nav-text">控制语句</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#并发一致性问题"><span class="nav-number">1.5.3.</span> <span class="nav-text">并发一致性问题</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#数据库提供一定的隔离级别解决上述问题"><span class="nav-number">1.5.3.1.</span> <span class="nav-text">数据库提供一定的隔离级别解决上述问题</span></a></li></ol></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#常见面试题"><span class="nav-number">1.6.</span> <span class="nav-text">常见面试题</span></a></li></ol></li></ol></div>
            

          </div>
        </section>
      <!--/noindex-->
      

      

    </div>
  </aside>


        
      </div>
    </main>

    <footer id="footer" class="footer">
      <div class="footer-inner">
        <div class="copyright">&copy; <span itemprop="copyrightYear">2020</span>
  <span class="with-love">
    <i class="fa fa-user"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">HitoMeng</span>

  
</div>


  <div class="powered-by">Powered by <a class="theme-link" target="_blank" href="https://hexo.io">Hexo</a></div>



  <span class="post-meta-divider">|</span>



  <div class="theme-info">Theme &mdash; <a class="theme-link" target="_blank" href="https://github.com/iissnan/hexo-theme-next">NexT.Gemini</a> v5.1.4</div>




        







        
      </div>
    </footer>

    
      <div class="back-to-top">
        <i class="fa fa-arrow-up"></i>
        
      </div>
    

    

  </div>

  

<script type="text/javascript">
  if (Object.prototype.toString.call(window.Promise) !== '[object Function]') {
    window.Promise = null;
  }
</script>









  












  
  
    <script type="text/javascript" src="/java-notes/lib/jquery/index.js?v=2.1.3"></script>
  

  
  
    <script type="text/javascript" src="/java-notes/lib/fastclick/lib/fastclick.min.js?v=1.0.6"></script>
  

  
  
    <script type="text/javascript" src="/java-notes/lib/jquery_lazyload/jquery.lazyload.js?v=1.9.7"></script>
  

  
  
    <script type="text/javascript" src="/java-notes/lib/velocity/velocity.min.js?v=1.2.1"></script>
  

  
  
    <script type="text/javascript" src="/java-notes/lib/velocity/velocity.ui.min.js?v=1.2.1"></script>
  

  
  
    <script type="text/javascript" src="/java-notes/lib/fancybox/source/jquery.fancybox.pack.js?v=2.1.5"></script>
  


  


  <script type="text/javascript" src="/java-notes/js/src/utils.js?v=5.1.4"></script>

  <script type="text/javascript" src="/java-notes/js/src/motion.js?v=5.1.4"></script>



  
  


  <script type="text/javascript" src="/java-notes/js/src/affix.js?v=5.1.4"></script>

  <script type="text/javascript" src="/java-notes/js/src/schemes/pisces.js?v=5.1.4"></script>



  
  <script type="text/javascript" src="/java-notes/js/src/scrollspy.js?v=5.1.4"></script>
<script type="text/javascript" src="/java-notes/js/src/post-details.js?v=5.1.4"></script>



  


  <script type="text/javascript" src="/java-notes/js/src/bootstrap.js?v=5.1.4"></script>



  


  




	





  





  












  





  

  

  

  
  

  

  

  

</body>
</html>
